package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade INSTRUMENTO_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntInstrumentoEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.INSTRUMENTO_ENSAIO";
    public final static String TABLE_NAME = "INSTRUMENTO_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntInstrumentoEnsaio() {
        super();
        initialize();
    }
    
    public EntInstrumentoEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Sigla do instrumento (tag)"); 
        aNome.setRequired(true);
        aNome.setSize(32);
        oNome = new DomUpper();
        aAtivo = new DomFlag(this,"ATIVO", "Instrumento ativo"); 
        aAtivo.setRequired(true);
        aAtivo.setSize(1);
        aAtivo.setDefaultValue("S");
        oAtivo = new DomFlag();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição do instrumento"); 
        aDescricao.setRequired(true);
        oDescricao = new DomTextLong();
        aTipoInstrumentoEnsaioId = new DomId(this,"TIPO_INSTRUMENTO_ENSAIO_ID", "Tipo do instrumento de ensaio"); 
        aTipoInstrumentoEnsaioId.setRequired(true);
        oTipoInstrumentoEnsaioId = new DomId();
        aIntervaloValorInicial = new DomDouble(this,"INTERVALO_VALOR_INICIAL", "Intervalo (Valor inicial)"); 
        oIntervaloValorInicial = new DomDouble();
        aIntervaloValorFinal = new DomDouble(this,"INTERVALO_VALOR_FINAL", "Intervalo (Valor final)"); 
        oIntervaloValorFinal = new DomDouble();
        aDesvioPadraoAceitavel = new DomDouble(this,"DESVIO_PADRAO_ACEITAVEL", "Incerteza (desvio permitido)"); 
        oDesvioPadraoAceitavel = new DomDouble();
        aCertificado = new DomText(this,"CERTIFICADO", "Certificado do instrumento"); 
        oCertificado = new DomText();
        aDataValidadeCertificado = new DomDate(this,"DATA_VALIDADE_CERTIFICADO", "Validade do certificado do instrumento"); 
        oDataValidadeCertificado = new DomDate();
        aCodigo = new DomText(this,"CODIGO", "Código"); 
        aCodigo.setRequired(true);
        aCodigo.setSize(32);
        oCodigo = new DomText();
        aUnidadeMedida = new DomUpper(this,"UNIDADE_MEDIDA", "Unidade de medida do valor"); 
        oUnidadeMedida = new DomUpper();
        aCertificadoCalibracaoCorrenteId = new DomId(this,"CERTIFICADO_CALIBRACAO_CORRENTE_ID", "Certificado de calibração corrente"); 
        oCertificadoCalibracaoCorrenteId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Sigla do instrumento (tag)
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Instrumento ativo
    private DomFlag aAtivo;
    private DomFlag oAtivo;
    
    // Descrição do instrumento
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // Tipo do instrumento de ensaio
    private DomId aTipoInstrumentoEnsaioId;
    private DomId oTipoInstrumentoEnsaioId;
    
    // Intervalo (Valor inicial)
    private DomDouble aIntervaloValorInicial;
    private DomDouble oIntervaloValorInicial;
    
    // Intervalo (Valor final)
    private DomDouble aIntervaloValorFinal;
    private DomDouble oIntervaloValorFinal;
    
    // Incerteza (desvio permitido)
    private DomDouble aDesvioPadraoAceitavel;
    private DomDouble oDesvioPadraoAceitavel;
    
    // Certificado do instrumento
    private DomText aCertificado;
    private DomText oCertificado;
    
    // Validade do certificado do instrumento
    private DomDate aDataValidadeCertificado;
    private DomDate oDataValidadeCertificado;
    
    // Código
    private DomText aCodigo;
    private DomText oCodigo;
    
    // Unidade de medida do valor
    private DomUpper aUnidadeMedida;
    private DomUpper oUnidadeMedida;
    
    // Certificado de calibração corrente
    private DomId aCertificadoCalibracaoCorrenteId;
    private DomId oCertificadoCalibracaoCorrenteId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntInstrumentoEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntInstrumentoEnsaio nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ATIVO">
    
    public EntInstrumentoEnsaio ativo(String value) {
        setAtivo(value);
        return this;
    }
    
    public void setAtivo(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value.getValue());
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(String value) {
        if (value == null) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value);
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(Object value) {
        aAtivo.setValue(value);
        if (aAtivo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAtivo() {
        if (!aAtivo.isNull()) {
            aAtivo.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getAtivo() {
        return aAtivo;
    }
    
    public DomFlag oldAtivo() {
        return oAtivo;
    }
    
    public String valueOfAtivo() {
        return aAtivo.getValue();
    }
    
    public boolean isAtivoModified() {
        return aAtivo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntInstrumentoEnsaio descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_INSTRUMENTO_ENSAIO_ID">
    
    public EntInstrumentoEnsaio tipoInstrumentoEnsaioId(Long value) {
        setTipoInstrumentoEnsaioId(value);
        return this;
    }
    
    public void setTipoInstrumentoEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyTipoInstrumentoEnsaioId();
        } else {
            aTipoInstrumentoEnsaioId.setValue(value.getValue());
            if (aTipoInstrumentoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoInstrumentoEnsaioId(String value) {
        if (value == null) {
            nullifyTipoInstrumentoEnsaioId();
        } else {
            aTipoInstrumentoEnsaioId.setValue(value);
            if (aTipoInstrumentoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoInstrumentoEnsaioId(Long value) {
        aTipoInstrumentoEnsaioId.setValue(value);
        if (aTipoInstrumentoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setTipoInstrumentoEnsaioId(Object value) {
        aTipoInstrumentoEnsaioId.setValue(value);
        if (aTipoInstrumentoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoInstrumentoEnsaioId() {
        if (!aTipoInstrumentoEnsaioId.isNull()) {
            aTipoInstrumentoEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getTipoInstrumentoEnsaioId() {
        return aTipoInstrumentoEnsaioId;
    }
    
    public DomId oldTipoInstrumentoEnsaioId() {
        return oTipoInstrumentoEnsaioId;
    }
    
    public Long valueOfTipoInstrumentoEnsaioId() {
        return aTipoInstrumentoEnsaioId.getValue();
    }
    
    public boolean isTipoInstrumentoEnsaioIdModified() {
        return aTipoInstrumentoEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INTERVALO_VALOR_INICIAL">
    
    public EntInstrumentoEnsaio intervaloValorInicial(Double value) {
        setIntervaloValorInicial(value);
        return this;
    }
    
    public void setIntervaloValorInicial(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyIntervaloValorInicial();
        } else {
            aIntervaloValorInicial.setValue(value.getValue());
            if (aIntervaloValorInicial.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIntervaloValorInicial(String value) {
        if (value == null) {
            nullifyIntervaloValorInicial();
        } else {
            aIntervaloValorInicial.setValue(value);
            if (aIntervaloValorInicial.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIntervaloValorInicial(Double value) {
        aIntervaloValorInicial.setValue(value);
        if (aIntervaloValorInicial.isModified()) {
            setModified(true);
        }
    }
    
    public void setIntervaloValorInicial(Object value) {
        aIntervaloValorInicial.setValue(value);
        if (aIntervaloValorInicial.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyIntervaloValorInicial() {
        if (!aIntervaloValorInicial.isNull()) {
            aIntervaloValorInicial.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getIntervaloValorInicial() {
        return aIntervaloValorInicial;
    }
    
    public DomDouble oldIntervaloValorInicial() {
        return oIntervaloValorInicial;
    }
    
    public Double valueOfIntervaloValorInicial() {
        return aIntervaloValorInicial.getValue();
    }
    
    public boolean isIntervaloValorInicialModified() {
        return aIntervaloValorInicial.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INTERVALO_VALOR_FINAL">
    
    public EntInstrumentoEnsaio intervaloValorFinal(Double value) {
        setIntervaloValorFinal(value);
        return this;
    }
    
    public void setIntervaloValorFinal(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyIntervaloValorFinal();
        } else {
            aIntervaloValorFinal.setValue(value.getValue());
            if (aIntervaloValorFinal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIntervaloValorFinal(String value) {
        if (value == null) {
            nullifyIntervaloValorFinal();
        } else {
            aIntervaloValorFinal.setValue(value);
            if (aIntervaloValorFinal.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIntervaloValorFinal(Double value) {
        aIntervaloValorFinal.setValue(value);
        if (aIntervaloValorFinal.isModified()) {
            setModified(true);
        }
    }
    
    public void setIntervaloValorFinal(Object value) {
        aIntervaloValorFinal.setValue(value);
        if (aIntervaloValorFinal.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyIntervaloValorFinal() {
        if (!aIntervaloValorFinal.isNull()) {
            aIntervaloValorFinal.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getIntervaloValorFinal() {
        return aIntervaloValorFinal;
    }
    
    public DomDouble oldIntervaloValorFinal() {
        return oIntervaloValorFinal;
    }
    
    public Double valueOfIntervaloValorFinal() {
        return aIntervaloValorFinal.getValue();
    }
    
    public boolean isIntervaloValorFinalModified() {
        return aIntervaloValorFinal.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESVIO_PADRAO_ACEITAVEL">
    
    public EntInstrumentoEnsaio desvioPadraoAceitavel(Double value) {
        setDesvioPadraoAceitavel(value);
        return this;
    }
    
    public void setDesvioPadraoAceitavel(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyDesvioPadraoAceitavel();
        } else {
            aDesvioPadraoAceitavel.setValue(value.getValue());
            if (aDesvioPadraoAceitavel.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDesvioPadraoAceitavel(String value) {
        if (value == null) {
            nullifyDesvioPadraoAceitavel();
        } else {
            aDesvioPadraoAceitavel.setValue(value);
            if (aDesvioPadraoAceitavel.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDesvioPadraoAceitavel(Double value) {
        aDesvioPadraoAceitavel.setValue(value);
        if (aDesvioPadraoAceitavel.isModified()) {
            setModified(true);
        }
    }
    
    public void setDesvioPadraoAceitavel(Object value) {
        aDesvioPadraoAceitavel.setValue(value);
        if (aDesvioPadraoAceitavel.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDesvioPadraoAceitavel() {
        if (!aDesvioPadraoAceitavel.isNull()) {
            aDesvioPadraoAceitavel.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getDesvioPadraoAceitavel() {
        return aDesvioPadraoAceitavel;
    }
    
    public DomDouble oldDesvioPadraoAceitavel() {
        return oDesvioPadraoAceitavel;
    }
    
    public Double valueOfDesvioPadraoAceitavel() {
        return aDesvioPadraoAceitavel.getValue();
    }
    
    public boolean isDesvioPadraoAceitavelModified() {
        return aDesvioPadraoAceitavel.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CERTIFICADO">
    
    public EntInstrumentoEnsaio certificado(String value) {
        setCertificado(value);
        return this;
    }
    
    public void setCertificado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyCertificado();
        } else {
            aCertificado.setValue(value.getValue());
            if (aCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificado(String value) {
        if (value == null) {
            nullifyCertificado();
        } else {
            aCertificado.setValue(value);
            if (aCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificado(Object value) {
        aCertificado.setValue(value);
        if (aCertificado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCertificado() {
        if (!aCertificado.isNull()) {
            aCertificado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getCertificado() {
        return aCertificado;
    }
    
    public DomText oldCertificado() {
        return oCertificado;
    }
    
    public String valueOfCertificado() {
        return aCertificado.getValue();
    }
    
    public boolean isCertificadoModified() {
        return aCertificado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_VALIDADE_CERTIFICADO">
    
    public EntInstrumentoEnsaio dataValidadeCertificado(java.sql.Date value) {
        setDataValidadeCertificado(value);
        return this;
    }
    
    public void setDataValidadeCertificado(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataValidadeCertificado();
        } else {
            aDataValidadeCertificado.setValue(value.getValue());
            if (aDataValidadeCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataValidadeCertificado(String value) {
        if (value == null) {
            nullifyDataValidadeCertificado();
        } else {
            aDataValidadeCertificado.setValue(value);
            if (aDataValidadeCertificado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataValidadeCertificado(java.sql.Date value) {
        aDataValidadeCertificado.setValue(value);
        if (aDataValidadeCertificado.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataValidadeCertificado(Object value) {
        aDataValidadeCertificado.setValue(value);
        if (aDataValidadeCertificado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataValidadeCertificado() {
        if (!aDataValidadeCertificado.isNull()) {
            aDataValidadeCertificado.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataValidadeCertificado() {
        return aDataValidadeCertificado;
    }
    
    public DomDate oldDataValidadeCertificado() {
        return oDataValidadeCertificado;
    }
    
    public java.sql.Date valueOfDataValidadeCertificado() {
        return aDataValidadeCertificado.getValue();
    }
    
    public boolean isDataValidadeCertificadoModified() {
        return aDataValidadeCertificado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CODIGO">
    
    public EntInstrumentoEnsaio codigo(String value) {
        setCodigo(value);
        return this;
    }
    
    public void setCodigo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value.getValue());
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(String value) {
        if (value == null) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value);
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(Object value) {
        aCodigo.setValue(value);
        if (aCodigo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCodigo() {
        if (!aCodigo.isNull()) {
            aCodigo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getCodigo() {
        return aCodigo;
    }
    
    public DomText oldCodigo() {
        return oCodigo;
    }
    
    public String valueOfCodigo() {
        return aCodigo.getValue();
    }
    
    public boolean isCodigoModified() {
        return aCodigo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo UNIDADE_MEDIDA">
    
    public EntInstrumentoEnsaio unidadeMedida(String value) {
        setUnidadeMedida(value);
        return this;
    }
    
    public void setUnidadeMedida(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyUnidadeMedida();
        } else {
            aUnidadeMedida.setValue(value.getValue());
            if (aUnidadeMedida.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUnidadeMedida(String value) {
        if (value == null) {
            nullifyUnidadeMedida();
        } else {
            aUnidadeMedida.setValue(value);
            if (aUnidadeMedida.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUnidadeMedida(Object value) {
        aUnidadeMedida.setValue(value);
        if (aUnidadeMedida.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUnidadeMedida() {
        if (!aUnidadeMedida.isNull()) {
            aUnidadeMedida.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getUnidadeMedida() {
        return aUnidadeMedida;
    }
    
    public DomUpper oldUnidadeMedida() {
        return oUnidadeMedida;
    }
    
    public String valueOfUnidadeMedida() {
        return aUnidadeMedida.getValue();
    }
    
    public boolean isUnidadeMedidaModified() {
        return aUnidadeMedida.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CERTIFICADO_CALIBRACAO_CORRENTE_ID">
    
    public EntInstrumentoEnsaio certificadoCalibracaoCorrenteId(Long value) {
        setCertificadoCalibracaoCorrenteId(value);
        return this;
    }
    
    public void setCertificadoCalibracaoCorrenteId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyCertificadoCalibracaoCorrenteId();
        } else {
            aCertificadoCalibracaoCorrenteId.setValue(value.getValue());
            if (aCertificadoCalibracaoCorrenteId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificadoCalibracaoCorrenteId(String value) {
        if (value == null) {
            nullifyCertificadoCalibracaoCorrenteId();
        } else {
            aCertificadoCalibracaoCorrenteId.setValue(value);
            if (aCertificadoCalibracaoCorrenteId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificadoCalibracaoCorrenteId(Long value) {
        aCertificadoCalibracaoCorrenteId.setValue(value);
        if (aCertificadoCalibracaoCorrenteId.isModified()) {
            setModified(true);
        }
    }
    
    public void setCertificadoCalibracaoCorrenteId(Object value) {
        aCertificadoCalibracaoCorrenteId.setValue(value);
        if (aCertificadoCalibracaoCorrenteId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCertificadoCalibracaoCorrenteId() {
        if (!aCertificadoCalibracaoCorrenteId.isNull()) {
            aCertificadoCalibracaoCorrenteId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getCertificadoCalibracaoCorrenteId() {
        return aCertificadoCalibracaoCorrenteId;
    }
    
    public DomId oldCertificadoCalibracaoCorrenteId() {
        return oCertificadoCalibracaoCorrenteId;
    }
    
    public Long valueOfCertificadoCalibracaoCorrenteId() {
        return aCertificadoCalibracaoCorrenteId.getValue();
    }
    
    public boolean isCertificadoCalibracaoCorrenteIdModified() {
        return aCertificadoCalibracaoCorrenteId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.INSTRUMENTO_UTILIZADO_ENSAIO.FK_IUTE_DISPOSITIVO
        {
            EntInstrumentoUtilizadoEnsaio external = new EntInstrumentoUtilizadoEnsaio(ctx);
            external.findByInstrumentoEnsaio(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUMENTO_UTILIZADO_ENSAIO.FK_IUTE_DISPOSITIVO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instrumentos utilizandos nos ensaios fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.ENSAIO_BANCADA.FK_ENBANC_BANCADA_ENSAIO
        {
            EntEnsaioBancada external = new EntEnsaioBancada(ctx);
            external.findByBancadaEnsaio(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_BANCADA_ENSAIO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.CERTIFICADO_CALIBRACAO.FK_CERCAL_INSTRUMENTO_ENSAIO
        {
            EntCertificadoCalibracao certificadoCalibracao = new EntCertificadoCalibracao(ctx);
            certificadoCalibracao.del("select id from CERTIFICADO_CALIBRACAO where INSTRUMENTO_ENSAIO_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.INSTRUMENTO_UTILIZADO_ENSAIO.FK_IUTE_INSTRUMENTO_BASE
        {
            EntInstrumentoUtilizadoEnsaio instrumentoUtilizadoEnsaio = new EntInstrumentoUtilizadoEnsaio(ctx);
            instrumentoUtilizadoEnsaio.del("select id from INSTRUMENTO_UTILIZADO_ENSAIO where INSTRUMENTO_BASE_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.MODELO_ENSAIO_INTRUMENTO.FK_MENAIN_BANCADA_ENSAIO
        {
            EntModeloEnsaioIntrumento modeloEnsaioIntrumento = new EntModeloEnsaioIntrumento(ctx);
            modeloEnsaioIntrumento.del("select id from MODELO_ENSAIO_INTRUMENTO where INSTRUMENTO_ENSAIO_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.OPERADOR_INSTRUMENTO.FK_OPRINS_INSTRUMENTO
        {
            EntOperadorInstrumento operadorInstrumento = new EntOperadorInstrumento(ctx);
            operadorInstrumento.del("select id from OPERADOR_INSTRUMENTO where INSTRUMENTO_ENSAIO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_IUTE_DISPOSITIVO") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_UTILIZADO_ENSAIO.FK_IUTE_DISPOSITIVO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instrumentos utilizandos nos ensaios fazendo referencia para este registro! (FK_IUTE_DISPOSITIVO)");
                return e;
            } else if (msg.indexOf("FK_ENBANC_BANCADA_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_BANCADA_ENSAIO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro! (FK_ENBANC_BANCADA_ENSAIO)");
                return e;
            } else {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE", 
                        Severity.ERROR,
                        "Registro não cadastrado para CERTIFICADO_CALIBRACAO_CORRENTE! (FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE)");
                return e;
            } else if (msg.indexOf("CONFERIR_UNIDADE_MEDIDA_INTERVALOS") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.CONFERIR_UNIDADE_MEDIDA_INTERVALOS", 
                        Severity.ERROR,
                        "Regra inválida! A Unidade de medida deve ser informada se o intervalo inicial e/ou final está preenchido! (CONFERIR_UNIDADE_MEDIDA_INTERVALOS)");
                return e;
            } else if (msg.indexOf("UK_INEN_CODIGO") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.UK_INEN_CODIGO", 
                        Severity.ERROR,
                        "Registro duplicado! Código de identificação do instrumento deve ser único Código ${CODIGO} (UK_INEN_CODIGO)");
                return e;
            } else if (msg.indexOf("FK_INEN_TIPO_INSTRUMENTO") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_TIPO_INSTRUMENTO", 
                        Severity.ERROR,
                        "Registro não cadastrado para TIPO_INSTRUMENTO_ENSAIO! (FK_INEN_TIPO_INSTRUMENTO)");
                return e;
            } else if (msg.indexOf("UK_INEN_NOME") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.UK_INEN_NOME", 
                        Severity.ERROR,
                        "Registro duplicado! Nome da bancada de ensaio deve ser única Sigla do instrumento (tag) ${NOME} (UK_INEN_NOME)");
                return e;
            } else if (msg.indexOf("PK_INEN") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.PK_INEN", 
                        Severity.ERROR,
                        "ID duplicado! (PK_INEN)");
                return e;
            } else {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aAtivo);
            allAttributes.add(aDescricao);
            allAttributes.add(aTipoInstrumentoEnsaioId);
            allAttributes.add(aIntervaloValorInicial);
            allAttributes.add(aIntervaloValorFinal);
            allAttributes.add(aDesvioPadraoAceitavel);
            allAttributes.add(aCertificado);
            allAttributes.add(aDataValidadeCertificado);
            allAttributes.add(aCodigo);
            allAttributes.add(aUnidadeMedida);
            allAttributes.add(aCertificadoCalibracaoCorrenteId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNome(String nome) throws AdsException {
        findBy(new String[] {"NOME"},
                new Object[] {nome});
    }
    
    public void findByCodigo(String codigo) throws AdsException {
        findBy(new String[] {"CODIGO"},
                new Object[] {codigo});
    }
    
    private EntCertificadoCalibracao eCertificadoCalibracaoCorrente;
    
    public EntCertificadoCalibracao findCertificadoCalibracaoCorrente() throws AdsException {
        if (getCertificadoCalibracaoCorrenteId().isNull()) {
            return null;
        }
        if (eCertificadoCalibracaoCorrente == null || !valueOfCertificadoCalibracaoCorrenteId().equals(eCertificadoCalibracaoCorrente.valueOfId())) {
            eCertificadoCalibracaoCorrente = new EntCertificadoCalibracao(ctx);
            eCertificadoCalibracaoCorrente.find(valueOfCertificadoCalibracaoCorrenteId());
        }
        return eCertificadoCalibracaoCorrente;
    }
    
    /**
     * Ativa o join desta entidade com CERTIFICADO_CALIBRACAO
     * através do atributo CERTIFICADO_CALIBRACAO_CORRENTE_ID
     */
    public EntCertificadoCalibracao joinCertificadoCalibracaoCorrente() {
        return joinCertificadoCalibracaoCorrente(null);
    }
    public EntCertificadoCalibracao joinCertificadoCalibracaoCorrente(String alias) {
        EntCertificadoCalibracao entity = new EntCertificadoCalibracao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getCertificadoCalibracaoCorrenteId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByCertificadoCalibracaoCorrente(long id, String sqlAppend) throws AdsException {
        find("select ID from INSTRUMENTO_ENSAIO where CERTIFICADO_CALIBRACAO_CORRENTE_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByCertificadoCalibracaoCorrente(long id) throws AdsException {
        findByCertificadoCalibracaoCorrente(id,"");
    }
    
    public void findByCertificadoCalibracaoCorrente(Entity entidade) throws AdsException {
        findByCertificadoCalibracaoCorrente(entidade.valueOfId(),"");
    }
    
    public void findByCertificadoCalibracaoCorrente(Entity entidade, String sqlAppend) throws AdsException {
        findByCertificadoCalibracaoCorrente(entidade.valueOfId(),sqlAppend);
    }
    
    private EntTipoInstrumentoEnsaio eTipoInstrumentoEnsaio;
    
    public EntTipoInstrumentoEnsaio findTipoInstrumentoEnsaio() throws AdsException {
        if (getTipoInstrumentoEnsaioId().isNull()) {
            return null;
        }
        if (eTipoInstrumentoEnsaio == null || !valueOfTipoInstrumentoEnsaioId().equals(eTipoInstrumentoEnsaio.valueOfId())) {
            eTipoInstrumentoEnsaio = new EntTipoInstrumentoEnsaio(ctx);
            eTipoInstrumentoEnsaio.find(valueOfTipoInstrumentoEnsaioId());
        }
        return eTipoInstrumentoEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com TIPO_INSTRUMENTO_ENSAIO
     * através do atributo TIPO_INSTRUMENTO_ENSAIO_ID
     */
    public EntTipoInstrumentoEnsaio joinTipoInstrumentoEnsaio() {
        return joinTipoInstrumentoEnsaio(null);
    }
    public EntTipoInstrumentoEnsaio joinTipoInstrumentoEnsaio(String alias) {
        EntTipoInstrumentoEnsaio entity = new EntTipoInstrumentoEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getTipoInstrumentoEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByTipoInstrumentoEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from INSTRUMENTO_ENSAIO where TIPO_INSTRUMENTO_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByTipoInstrumentoEnsaio(long id) throws AdsException {
        findByTipoInstrumentoEnsaio(id,"");
    }
    
    public void findByTipoInstrumentoEnsaio(Entity entidade) throws AdsException {
        findByTipoInstrumentoEnsaio(entidade.valueOfId(),"");
    }
    
    public void findByTipoInstrumentoEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findByTipoInstrumentoEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eCertificadoCalibracaoCorrente = null;
        eTipoInstrumentoEnsaio = null;
    }
    /**
     * Retorna os registros de CERTIFICADO_CALIBRACAO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntCertificadoCalibracao findAllCertificadoCalibracaoInstrumentoEnsaio() throws AdsException {
        return findAllCertificadoCalibracaoInstrumentoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de CERTIFICADO_CALIBRACAO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntCertificadoCalibracao findAllCertificadoCalibracaoInstrumentoEnsaio(String sqlAppend) throws AdsException {
        EntCertificadoCalibracao out = new EntCertificadoCalibracao(ctx);
        out.find("select ID from CERTIFICADO_CALIBRACAO where INSTRUMENTO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de MODELO_ENSAIO_INTRUMENTO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntModeloEnsaioIntrumento findAllModeloEnsaioIntrumentoInstrumentoEnsaio() throws AdsException {
        return findAllModeloEnsaioIntrumentoInstrumentoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de MODELO_ENSAIO_INTRUMENTO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntModeloEnsaioIntrumento findAllModeloEnsaioIntrumentoInstrumentoEnsaio(String sqlAppend) throws AdsException {
        EntModeloEnsaioIntrumento out = new EntModeloEnsaioIntrumento(ctx);
        out.find("select ID from MODELO_ENSAIO_INTRUMENTO where INSTRUMENTO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de OPERADOR_INSTRUMENTO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntOperadorInstrumento findAllOperadorInstrumentoInstrumentoEnsaio() throws AdsException {
        return findAllOperadorInstrumentoInstrumentoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de OPERADOR_INSTRUMENTO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntOperadorInstrumento findAllOperadorInstrumentoInstrumentoEnsaio(String sqlAppend) throws AdsException {
        EntOperadorInstrumento out = new EntOperadorInstrumento(ctx);
        out.find("select ID from OPERADOR_INSTRUMENTO where INSTRUMENTO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_UTILIZADO_ENSAIO que referenciam este registro através do atributo INSTRUMENTO_BASE_ID
     */
    public EntInstrumentoUtilizadoEnsaio findAllInstrumentoUtilizadoEnsaioInstrumentoBase() throws AdsException {
        return findAllInstrumentoUtilizadoEnsaioInstrumentoBase("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_UTILIZADO_ENSAIO que referenciam este registro através do atributo INSTRUMENTO_BASE_ID
     */
    public EntInstrumentoUtilizadoEnsaio findAllInstrumentoUtilizadoEnsaioInstrumentoBase(String sqlAppend) throws AdsException {
        EntInstrumentoUtilizadoEnsaio out = new EntInstrumentoUtilizadoEnsaio(ctx);
        out.find("select ID from INSTRUMENTO_UTILIZADO_ENSAIO where INSTRUMENTO_BASE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_UTILIZADO_ENSAIO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntInstrumentoUtilizadoEnsaio findAllInstrumentoUtilizadoEnsaioInstrumentoEnsaio() throws AdsException {
        return findAllInstrumentoUtilizadoEnsaioInstrumentoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_UTILIZADO_ENSAIO que referenciam este registro através do atributo INSTRUMENTO_ENSAIO_ID
     */
    public EntInstrumentoUtilizadoEnsaio findAllInstrumentoUtilizadoEnsaioInstrumentoEnsaio(String sqlAppend) throws AdsException {
        EntInstrumentoUtilizadoEnsaio out = new EntInstrumentoUtilizadoEnsaio(ctx);
        out.find("select ID from INSTRUMENTO_UTILIZADO_ENSAIO where INSTRUMENTO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo BANCADA_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaBancadaEnsaio() throws AdsException {
        return findAllEnsaioBancadaBancadaEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo BANCADA_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaBancadaEnsaio(String sqlAppend) throws AdsException {
        EntEnsaioBancada out = new EntEnsaioBancada(ctx);
        out.find("select ID from ENSAIO_BANCADA where BANCADA_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oCertificadoCalibracaoCorrenteId.setValue(aCertificadoCalibracaoCorrenteId);
        oUnidadeMedida.setValue(aUnidadeMedida);
        oCodigo.setValue(aCodigo);
        oCertificado.setValue(aCertificado);
        oDesvioPadraoAceitavel.setValue(aDesvioPadraoAceitavel);
        oDataValidadeCertificado.setValue(aDataValidadeCertificado);
        oAtivo.setValue(aAtivo);
        oIntervaloValorInicial.setValue(aIntervaloValorInicial);
        oIntervaloValorFinal.setValue(aIntervaloValorFinal);
        oTipoInstrumentoEnsaioId.setValue(aTipoInstrumentoEnsaioId);
        oId.setValue(aId);
        oNome.setValue(aNome);
        oDescricao.setValue(aDescricao);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntInstrumentoEnsaio.class);
            rule.setName("PK_INEN");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntInstrumentoEnsaio.class);
            rule.setAssociatedEntity(EntCertificadoCalibracao.class);
            rule.setName("FK_INEN_CERTIFICADO_CALIBRACAO_CORRENTE");
            rule.addAttribute(new DomId("CERTIFICADO_CALIBRACAO_CORRENTE_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntInstrumentoEnsaio.class);
            rule.setAssociatedEntity(EntTipoInstrumentoEnsaio.class);
            rule.setName("FK_INEN_TIPO_INSTRUMENTO");
            rule.addAttribute(new DomId("TIPO_INSTRUMENTO_ENSAIO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntInstrumentoEnsaio.class);
            rule.setName("UK_INEN_NOME");
            rule.addAttribute(new DomUpper("NOME",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntInstrumentoEnsaio.class);
            rule.setName("UK_INEN_CODIGO");
            rule.addAttribute(new DomText("CODIGO",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        checkRule(isConferirUnidadeMedidaIntervalosValid(), "CONFERIR_UNIDADE_MEDIDA_INTERVALOS", "A Unidade de medida deve ser informada se o intervalo inicial e/ou final está preenchido!");
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        checkRule(isConferirUnidadeMedidaIntervalosValid(), "CONFERIR_UNIDADE_MEDIDA_INTERVALOS", "A Unidade de medida deve ser informada se o intervalo inicial e/ou final está preenchido!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getAtivo().isNull()) {
            setAtivo(getAtivo().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de validação: A Unidade de medida deve ser informada se o intervalo inicial e/ou final está preenchido!
     */
    private Object isConferirUnidadeMedidaIntervalosValid() throws AdsException {
        // <user-code id="21785945" parentId="21785851" hashcode="-59145661" length="155">
        if (getIntervaloValorInicial().isNotNull() ||
            getIntervaloValorFinal().isNotNull()) 
        {
            return getUnidadeMedida().isNotNull();
        }
        return true;
        
        // </user-code>
    }
}
